home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / tools / zmc3v078 / zmc3v078.lzh / SRCSV078.LZH / BRACKET.C < prev    next >
C/C++ Source or Header  |  2000-06-01  |  49KB  |  1,880 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #include "etc.h"
  6. #include "makezmd1.h"
  7. #include "makezmd2.h"
  8. #include "makezmd3.h"
  9. #include "parsesub.h"
  10. #include "velo.h"
  11. #include "68lib.h"
  12. #include "arcc.h"
  13. #include "portamnt.h"
  14.  
  15. #include "structs.h"
  16. #include "structs2.h"
  17. UBYTE *makeZmdCommand(UBYTE *zms,TRKCHINF *trkdata, BYTE target[],
  18.                         TRKINF *trkinf,COMMONINF *cominf);
  19. UBYTE *makeCHfader(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  20.                     TRKINF *trkinf, COMMONINF *cominf, int trk_fader);
  21. UBYTE *makeZmdEffect(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[]);
  22. UBYTE *makeZmdEffect2(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  23.                         const BYTE mode);
  24. UBYTE *makeZmdInstrumentId(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[]);
  25. UBYTE *makeZmdSynchronize(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  26.                             COMMONINF *cominf);
  27. UBYTE *makeZmdBar(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  28. UBYTE *makeZmdTieMode(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  29. UBYTE *makeZmdTrackMode(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf,
  30.                         const BYTE target[]);
  31. UBYTE *makeZmdTrackDelay(UBYTE *zms_, TRKCHINF *trkdata, const BYTE target[],
  32.                     TRKINF *trkinf, COMMONINF *cominf, int mode);
  33. void makeZmdAllSoundOff(TRKCHINF *trkdata, const BYTE target[]);
  34. UBYTE *makeZmdEcho(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf,
  35.                         const BYTE target[], COMMONINF *cominf);
  36. UBYTE *makeZmdDamper(UBYTE *zms, TRKCHINF *trkdata,
  37.                          const BYTE target[], int mode);
  38. UBYTE *makeZmdBendRange(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  39. UBYTE *makeZmdProgramChange(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  40. UBYTE *makeZmdProgramBankChange(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  41. UBYTE *makeZmdSetNRPN(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  42. UBYTE *makeZmdKsign(UBYTE *zms, const BYTE target[],TRKINF *trkinf);
  43. UBYTE *makeZmdReplay(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[]);
  44. void makeZmdDummy(TRKCHINF *trkdata, const BYTE target[]);
  45. UBYTE *makeZmdComment(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  46. UBYTE *makeZmdEvent(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[]);
  47. UBYTE *makeZmdPanpot(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[], int mode);
  48. UBYTE *makeZmdTempo(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[], int mode);
  49. UBYTE *makeZmdVolume(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  50.                         TRKINF *trkinf, int mode);
  51. UBYTE *makeZmdExclusive(UBYTE *zms,TRKCHINF *trkdata,
  52.                             const BYTE target[], UBYTE mode);
  53. void makeZmdPitch(TRKCHINF *trkdata, int Trk, int st, DWORD var);
  54. UBYTE *makeZmdBend(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf, const BYTE target[], int st);
  55. UBYTE *makeZmdProgramSplit(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf, const BYTE target[]);
  56. UBYTE *getZmsNoteSub(UBYTE *zms, TRKINF *trkinf, const int Trk, BYTE *note);
  57.  
  58. extern DWORD line;
  59. extern char *linebuf;
  60. extern LINEDATA *ld;
  61.  
  62. enum {
  63. #define ZMSCOMMAND(c,s) c,
  64. #include "trkcmd.h"
  65. #include "zmscmd.h"
  66. #undef ZMSCOMMAND
  67. dummy        /* it's needed for BCB */
  68. };
  69.  
  70.  
  71.  
  72. UBYTE *makeZmdCommand(UBYTE *zms,TRKCHINF *trkdata, BYTE target[],
  73.                         TRKINF *trkinf,COMMONINF *cominf)
  74. {                                                                /* |: |n | */
  75.     int trk,i;
  76.     UBYTE *zms_ = zms;
  77.     /* DWORD line_ = line; */
  78.  
  79.     const struct {
  80.         int zmscmdcode;
  81.         char *zmscmd;
  82.     } comtbl1[] = {
  83. #define ZMSCOMMAND(c,s) {c, s},
  84. #include "trkcmd.h"
  85. #include "zmscmd.h"
  86. #undef ZMSCOMMAND
  87.         {-1, NULL},
  88.     };
  89.  
  90.     for (i = 0;;i++) {
  91.         if (!comtbl1[i].zmscmd) break;
  92.         if (!stricmp2(zms,comtbl1[i].zmscmd)) {
  93.             zms += strlen(comtbl1[i].zmscmd);
  94.             break;
  95.         }
  96.     }
  97.     i = comtbl1[i].zmscmdcode;
  98.  
  99.     switch (i) {
  100.         case ZMSCMD_DC:                                        /* [d.c.] */
  101. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  102.                 *trkdata[target[trk]].zmd++ = 0xC5;
  103.                 *trkdata[target[trk]].zmd++ = 0x00;
  104.             }
  105.             break;
  106.         case ZMSCMD_SEGNO:                                    /* [segno] */
  107.         case ZMSCMD_DOLLAR:                                    /* [$] */
  108. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  109.                 int Trk = target[trk];
  110.                 do {
  111.                     *trkdata[Trk].zmd++ = 0xD0;
  112.                     if (!trkinf[Trk].segno) {
  113.                         trkinf[Trk].segno = trkdata[Trk].zmd - trkdata[Trk].zmdbuf;
  114.                     }
  115.                     putDword(trkdata[Trk].zmd, 0);
  116.                     trkdata[Trk].zmd += 4;
  117.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  118.             }
  119.             break;
  120.         case ZMSCMD_DS:                                        /* [d.s.] */
  121. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  122.                 int Trk = target[trk];
  123.                 do {
  124.                     if (!trkinf[Trk].segno) {
  125.                         zmserror("[d.s.] command must comes after [segno] or [$].",line,linebuf,zms_,0,1);
  126.                     }
  127.                     *trkdata[Trk].zmd++ = 0xD3;
  128.                     putDword(trkdata[Trk].zmdbuf + trkinf[Trk].segno,
  129.                         trkdata[Trk].zmd - trkdata[Trk].zmdbuf - trkinf[Trk].segno - 4);
  130.                     *trkdata[Trk].zmd++ = 0x00;
  131.                     putDword(trkdata[Trk].zmd, 
  132.                     trkinf[Trk].segno - (trkdata[Trk].zmd - trkdata[Trk].zmdbuf));
  133.                     trkdata[Trk].zmd += 4;
  134.                     trkinf[Trk].segno = 0;
  135.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  136.             }
  137.             break;
  138.         case ZMSCMD_CODA:                                    /* [coda] */
  139. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  140.                 int Trk = target[trk];
  141.                 do {
  142.                     if (!trkinf[Trk].coda) {
  143.                         zmserror("[coda] command must comes after [tocoda] or [$].",line,linebuf,zms_,0,1);
  144.                     }
  145.                     *trkdata[Trk].zmd++ = 0xD1;
  146.                     putDword(trkdata[Trk].zmd, 
  147.                         trkinf[Trk].coda - (trkdata[Trk].zmd - trkdata[Trk].zmdbuf) - 4);
  148.                     putDword(trkdata[Trk].zmdbuf + trkinf[Trk].coda + 1,
  149.                         trkdata[Trk].zmd - trkdata[Trk].zmdbuf - trkinf[Trk].coda - 1);
  150.                     trkdata[Trk].zmd += 4;
  151.  
  152.                     trkinf[Trk].coda = 0;
  153.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  154.             }
  155.             break;
  156.         case ZMSCMD_TOCODA:                                    /* [tocoda] */
  157.         case ZMSCMD_ASTARISK:                                /* [*] */
  158. /*OK?*/        for (trk = 0; target[trk] >= 0; trk++) {
  159.                 int Trk = target[trk];
  160.                 do {
  161.                     *trkdata[Trk].zmd++ = 0xD4;
  162.                     if (!trkinf[Trk].coda) {
  163.                         trkinf[Trk].coda = trkdata[Trk].zmd - trkdata[Trk].zmdbuf;
  164.                     }
  165.                     *trkdata[Trk].zmd++ = 0x00;
  166.                     putDword(trkdata[Trk].zmd, 0);
  167.                     trkdata[Trk].zmd += 4;
  168.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  169.             }
  170.             break;
  171.         case ZMSCMD_FINE:                                    /* [fine] */
  172.         case ZMSCMD_FINE2:                                    /* [^] */
  173. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  174.                 int Trk = target[trk];
  175.                 do {
  176.                     *trkdata[Trk].zmd++ = 0xFC;
  177.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  178.             }
  179.             break;
  180.         case ZMSCMD_DO:                                        /* [do] */
  181. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  182.                 int Trk = target[trk];
  183.                 do {
  184.                     recoverSpecialVelocity(trkinf, Trk);
  185.                     trkinf[Trk].d->looptime = 1;
  186.  
  187.                     *trkdata[Trk].zmd++ = 0xC5;
  188.                     *trkdata[Trk].zmd++ = 0x01;
  189.                     *trkdata[Trk].zmd++ = 0x00;
  190.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  191.             }
  192.             break;
  193.         case ZMSCMD_LOOP:                                    /* [loop] */
  194. /*tenuki*/    for (trk = 0; target[trk] >= 0; trk++) {
  195.                 int Trk = target[trk];
  196.                 do {
  197.                     trkinf[Trk].d->looptime = 0;
  198.                     *trkdata[Trk].zmd++ = 0xF5;
  199.                     putDword(trkdata[Trk].zmd, 0);
  200.                     trkdata[Trk].zmd += 4;
  201.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  202.             }
  203.             break;
  204.         case ZMSCMD_DEBUG1:                                    /* [!] */
  205. /*OK*/        if (cominf->debug) {
  206.                 for (trk = 0; target[trk] >= 0; trk++) {
  207.                     int Trk = target[trk];
  208.                     do {
  209.                         *trkdata[Trk].zmd++ = 0xC5;
  210.                         *trkdata[Trk].zmd++ = 0x02;
  211.                         *trkdata[Trk].zmd++ = 0x00;
  212.                     } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  213.                 }
  214.             } else {
  215.                 zmserror("debug command [!] is still existing.",line,linebuf,zms_,3,1);
  216.             }
  217.             break;
  218.         case ZMSCMD_DEBUG2:                                    /* [@] */
  219. /*OK*/        if (cominf->debug) {
  220.                 for (trk = 0; target[trk] >= 0; trk++) {
  221.                     int Trk = target[trk];
  222.                     do {
  223.                         *trkdata[Trk].zmd++ = 0xC5;
  224.                         *trkdata[Trk].zmd++ = 0x03;
  225.                         *trkdata[Trk].zmd++ = 0x02;
  226.                     } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  227.                 }
  228.             } else {
  229.                 zmserror("debug command [@] is still existing.",line,linebuf,zms_,2,1);
  230.             }
  231.             break;
  232.         case ZMSCMD_END:                                    /* [end] */
  233. /*OK*/        for (trk = 0; target[trk] >= 0; trk++) {
  234.                 int Trk = target[trk];
  235.                 do {
  236.                     *trkdata[Trk].zmd++ = 0xFF;
  237.                 } while (trkinf[Trk].back_repeat && (Trk = cominf->backtrk[Trk]) != -1);
  238.             }
  239.             break;
  240.         case ZMSCMD_BACK:                                    /* [back */
  241. /*OK?*/        for (trk = 0; target[trk] >= 0; trk++) {
  242.                 const int Trk = target[trk];
  243.                 DWORD    backtrk, notfirsttime = 1;
  244.  
  245.                 if (!stricmp2(zms,".repeat")) {    /* [back.repeat  */
  246.                     const char *p[] = {"off","on",NULL};
  247.                     DWORD para;
  248.                     int err;
  249.  
  250.                     zms = getnum4(zms + 7,¶,&err, p, 0);
  251.                     if (err) {
  252.                         zmserror("[back.repeat] needs a parameter.",line,linebuf,zms,0,1);
  253.                     } else {
  254.                         trkinf[Trk].back_repeat = para;
  255.                     }
  256.                 }
  257.  
  258.  
  259.                 if (cominf->backtrk[Trk] < 0) {        /* 1st time to use [back] in this trk */
  260.                     int i;
  261.                     for (i = 1; i < cominf->maxtrk; i++) {
  262.                         if (trkdata[i].ch < 0) {
  263.                             int trks;
  264.                             char s[32];
  265.                             sprintf(s,"trkdata[%d].zmdbuf_in_BACK",i);
  266.                             cominf->backtrk[Trk] = backtrk = i;
  267.                             cominf->fromtrk[i] = Trk;
  268.                             cominf->backtrk[i] = -1;
  269.                             cominf->backinuse = 1;
  270.                             trkdata[i].zmdbuf  = (UBYTE*)emalloc(sizeof(UBYTE) * 8192,s);
  271.                             trkdata[i].bufsize = 8192;
  272.                             trkdata[i].zmd     = trkdata[i].zmdbuf;
  273.                             trkdata[i].nowsize = 0;
  274.                             trkdata[i].mute    = 1;
  275.                             initTrkInf(&trkinf[i], cominf);
  276.  
  277.                             for (trks = 0; trks < cominf->maxtrk; trks++) {
  278.                                 if (cominf->trkassign[trks] < 0) {
  279.                                     cominf->trkassign[trks] = backtrk;
  280.                                     cominf->trkassign[trks + 1] = -1;
  281.                                     break;
  282.                                 }
  283.                             }
  284.                             trkinf[i].l = (LOOPDATA*)NULL;
  285.                             trkinf[i].d = (LOOPDATA*)NULL;
  286.                             trkinf[i].r = (RENP*)NULL;
  287.                             trkinf[i].s = (CHKSTEP*)NULL;
  288.                             notfirsttime = 0;
  289.                             break;
  290.                         }
  291.                     }
  292.                     if (i >= cominf->maxtrk) {
  293.                         zmserror("Sorry too many [back]. (however it will be modified soon)",line,linebuf,zms,0,1);
  294.                     } 
  295.                 } else {
  296.                     backtrk = cominf->backtrk[Trk];
  297.                     if (trkinf[backtrk].total > trkinf[Trk].total) {
  298.                         zmserror("Previous [back] sequence has not finished yet.",line,linebuf,zms,2,1);
  299.                     }
  300.                 }
  301.  
  302.                 if (notfirsttime && (trkinf[backtrk].total < trkinf[Trk].total)) {
  303.                     DWORD d = trkinf[Trk].total - trkinf[backtrk].total;
  304.                     *trkdata[backtrk].zmd++ = 0x80;            /* 休符挿入(0.69) */
  305.                     trkdata[backtrk].zmd   += putZvar(trkdata[backtrk].zmd, d);
  306.                     trkdata[backtrk].zmd   += putZvar(trkdata[backtrk].zmd, d);
  307.                 }
  308.  
  309.                 copyTrkInf(&trkinf[backtrk], &trkinf[Trk]);        /* copy current track setting */
  310.                 trkdata[backtrk].ch   = trkdata[Trk].ch;
  311.                 trkdata[backtrk].ch_  = trkdata[Trk].ch_;
  312.                 trkdata[backtrk].chtype = trkdata[Trk].chtype;
  313.                 trkdata[backtrk].trkv = trkdata[Trk].trkv;
  314.                 trkdata[backtrk].trkf = trkdata[Trk].trkf;
  315.                 trkdata[backtrk].trks = trkdata[Trk].trks;
  316.                 trkdata[backtrk].trkm = trkdata[Trk].trkm;
  317.                 trkdata[backtrk].cmnt = trkdata[Trk].cmnt;        /* free時注意！！ */
  318.                 trkdata[backtrk].backinuse = -1;
  319.  
  320.                 *trkdata[backtrk].zmd++ = 0xFB;            /* receiving sync. signal */
  321.                 /* if (trkinf[backtrk].transpose != trkinf[Trk].transpose) { */
  322.                     *trkdata[backtrk].zmd++ = 0xAB;        /* send transpose info. */
  323.                     *trkdata[backtrk].zmd++ = trkinf[Trk].transpose;
  324.                 /* } */
  325.  
  326.                 for (i = 0; i < cominf->maxtrk; i++) {    /* sending synchronous signal */
  327.                     if (cominf->trkassign[i] == backtrk) {
  328.                         *trkdata[Trk].zmd++ = 0xBE;
  329.                         putWord(trkdata[Trk].zmd, i);    /* - 1; */
  330.                         trkdata[Trk].zmd += 2;
  331.                         break;
  332.                     }
  333.                 }
  334.                 if (i >= cominf->maxtrk) {
  335.                     zmserror("illegal track number.",line,linebuf,zms,0,1);
  336.                 }
  337.  
  338.  
  339.  
  340.                 /* trkinf[backtrk] = trkinf[Trk]; */ /* already copied in copyTrkInf() */
  341.                 initTrkInf2(&trkinf[backtrk],backtrk);    /* don't copy the informations
  342.                                                 about {{..}}, |:..:|, & so on */
  343.  
  344.                 trkdata[Trk].backinuse = backtrk;
  345.                 target[trk] = backtrk;
  346.  
  347.                 zmserror("[back] can use only for zmc2/zmc3.",line,linebuf,zms,4,1);
  348.             }
  349.             return zms;        /* to avoid ']' check ... to be effective for [back.repeat] */
  350.             /* break; */
  351.  
  352.         case ZMSCMD_TIMBRE:                        /* [timbre] */
  353.         case ZMSCMD_PROGRAM:                    /* [program] */
  354.             zms = makeZmdProgramChange(zms, trkdata, target);
  355.             break;
  356.         case ZMSCMD_TIMBRE_BANK:                /* [timbre_bank] */
  357.         case ZMSCMD_PROGRAM_BANK:                /* [program_bank] */
  358.             zms = makeZmdProgramBankChange(zms, trkdata, target);
  359.             break;
  360.         case ZMSCMD_TIMBRE_SPLIT:                /* [timbre_split] */
  361.         case ZMSCMD_PROGRAM_SPLIT:                /* [program_split] */
  362.             zms = makeZmdProgramSplit(zms, trkdata, trkinf, target);
  363.             break;
  364.  
  365.         case ZMSCMD_BEND:                        /* [bend] */
  366.             zms = makeZmdBend(zms, trkdata, trkinf, target, 1);
  367.             break;
  368.         case ZMSCMD_BEND_SWITCH:                /* [bend.switch] */
  369.             {
  370.                 int trk, err;
  371.                 DWORD para;
  372.                 const char *p[] = {"off","on",NULL};
  373.  
  374.                 zms = getnum4(zms,¶,&err, p, 0);
  375.                 if (!err) {
  376.                     for (trk = 0; target[trk] >= 0; trk++) {
  377.                         const int Trk = target[trk];
  378.                         *trkdata[Trk].zmd++ = 0x98;
  379.                         *trkdata[Trk].zmd++ = para;
  380.                     }
  381.                 } else {
  382.                     zmserror("[BEND.SWITCH] require its parameter.",line,linebuf,zms,4,1);
  383.                 }
  384.             }
  385.             break;
  386.         case ZMSCMD_BEND_RANGE:                    /* [bend_range] */
  387.             zms = makeZmdBendRange(zms, trkdata, target);
  388.             break;
  389.         case ZMSCMD_PITCH:                        /* [pitch] */
  390.         case ZMSCMD_ATPITCH:                    /* [@pitch] */
  391.             {
  392.                 int trk, err;
  393.                 DWORD var;
  394.                 int st = (i == ZMSCMD_PITCH)? 1 : 3;
  395.  
  396.                 zms = getnum2(zms,&var,&err);
  397.                 if (!err) {
  398.                     for (trk = 0; target[trk] >= 0; trk++) {
  399.                         const int Trk = target[trk];
  400.                         makeZmdPitch(trkdata, Trk, st, var);
  401.                     }
  402.                 } else {
  403.                     zmserror("[PITCH]/[@PITCH] require its parameter.",line,linebuf,zms,4,1);
  404.                 }
  405.             }
  406.             break;
  407. /* [push_portament] */
  408. /* [pull_portament] */
  409. /* [auto_portament] */
  410. /* [auto_portament.switch] */
  411.  
  412.         case ZMSCMD_AUTO_PORTAMENT:                        /* [auto_portament] */
  413.             zms = makeZmdAutoPortament(zms, trkdata, trkinf, target);
  414.             break;
  415.         case ZMSCMD_AUTO_PORTAMENT_SWITCH:                /* [auto_portament.switch] */
  416.             zms = makeZmdAutoPortamentSwitch(zms, trkdata, target);
  417.             break;
  418.  
  419. /* [aftertouch.level] */
  420. /* [aftertouch.delay] */
  421. /* [aftertouch.switch] */
  422. /* [aftertouch.sync] */
  423. /* [vibrato.delth] */
  424. /* : */
  425.         case ZMSCMD_ARCC:                        /* [arcc..] */
  426.             zms = makeARCCCommand(zms,trkdata,target,trkinf);
  427.             break;
  428.  
  429.         case ZMSCMD_VOLUME:                        /* [volume] */
  430.             zms = makeZmdVolume(zms, trkdata, target, trkinf, 0);
  431.             break;
  432.         case ZMSCMD_ATVOLUME:                    /* [@volume] */
  433.             zms = makeZmdVolume(zms, trkdata, target, trkinf, 1);
  434.             break;
  435.         case ZMSCMD_VELOCITY:                    /* [velocity] */
  436.             /*zms = setMMLatU(zms, trkdata, trkinf, target, 0);*/
  437.             zms = dispatchVelo(zms,trkdata,trkinf,cominf,target);
  438.             break;
  439.         case ZMSCMD_ATVELOCITY:                    /* [@velocity] */
  440.             zms = setMMLatU(zms, trkdata, trkinf, target, 1);
  441.             break;
  442. #ifdef AAA
  443.         case ZMSCMD_VELOCITY_REVISE:            /* [velocity.revise] */
  444.             for (trk = 0; target[trk] >= 0; trk++) {
  445.                 zms = makeZmdRandVelo(zms + 6,trkdata,target[trk],
  446.                                         trkinf,cominf,line,linebuf);
  447.             }
  448.             zmserror("[velocity.revise] can use only for zmc2/zmc3.",line,linebuf,zms_,4,1);
  449.             break;
  450. #endif
  451.  
  452.         case ZMSCMD_PANPOT:                        /* [panpot] */
  453.         case ZMSCMD_ATPANPOT:                    /* [@panpot] */
  454.             {
  455.                 int mode = (i == ZMSCMD_PANPOT)? 0 : 1;
  456.                 zms = makeZmdPanpot(zms, trkdata, target, mode);
  457.             }
  458.             break;
  459.  
  460.         case ZMSCMD_TEMPO:                        /* [tempo] */
  461.         case ZMSCMD_ATTEMPO:                    /* [@tempo] */
  462.         case ZMSCMD_TIMER:                        /* [timer] */
  463.             {
  464.                 int mode;
  465.                 if (i == ZMSCMD_TEMPO) {
  466.                     mode = 0;
  467.                 } else if (i == ZMSCMD_ATTEMPO) {
  468.                     mode = 1;
  469.                 } else {
  470.                     mode = 2;
  471.                 }
  472.                 zms = makeZmdTempo(zms, trkdata, target, mode);
  473.             }
  474.             break;
  475.  
  476.         case ZMSCMD_TIE_MODE:                    /* [tie_mode] */
  477.             zms = makeZmdTieMode(zms, trkdata, target);
  478.             break;
  479.         case ZMSCMD_TRACK_MODE:                    /* [track_mode] */
  480.             zms = makeZmdTrackMode(zms, trkdata, trkinf, target);
  481.             break;
  482.         case ZMSCMD_TRACK_DELAY:                /* [track_delay] */
  483.             zms = makeZmdTrackDelay(zms, trkdata, target, trkinf, cominf, 1);
  484.             break;
  485.  
  486.         case ZMSCMD_ALL_SOUND_OFF:                /* [all_sound_off] */
  487.             makeZmdAllSoundOff(trkdata, target);
  488.             break;
  489.         case ZMSCMD_ECHO:                        /* [echo] */
  490.             zms = makeZmdEcho(zms, trkdata, trkinf, target,cominf);
  491.             break;
  492.         case ZMSCMD_KSIGN:                        /* [k.sign */
  493.         case ZMSCMD_KEY_SIGNATURE:                /* [key_signature */
  494.             zms = makeZmdKsign(zms, target, trkinf);
  495.             break;
  496.         case ZMSCMD_KEY:                        /* [key] */
  497.             zms = makeZmdKey(zms, cominf, trkdata, target);
  498.             break;
  499.         case ZMSCMD_METER:                        /* [meter] */
  500.             zms = makeZmdMeter(zms, cominf, trkdata, target);
  501.             break;
  502.         case ZMSCMD_BAR:                        /* [bar] */
  503.         case ZMSCMD_BAR2:                        /* [measure] */
  504.         case ZMSCMD_BAR3:                        /* [-] */
  505.             zms = makeZmdBar(zms,trkdata,target);
  506.             break;
  507.         case ZMSCMD_REPLAY:                        /* [replay] */
  508.             zms = makeZmdReplay(zms, trkdata, target);
  509.             break;
  510.         case ZMSCMD_SYNCHRONIZE:                /* [synchronize] */
  511.             zms = makeZmdSynchronize(zms, trkdata, target, cominf);
  512.             break;
  513.  
  514.         case ZMSCMD_DUMMY:                        /* [dummy] */
  515.             makeZmdDummy(trkdata, target);
  516.             break;
  517.         case ZMSCMD_COMMENT:                    /* [comment] */
  518.             zms = makeZmdComment(zms, trkdata, target);
  519.             break;
  520.         case ZMSCMD_EVENT:                        /* [event] */
  521.             zms = makeZmdEvent(zms, trkdata, target);
  522.             break;
  523.  
  524.         case ZMSCMD_CONTROL:                    /* [control] */
  525.             zms = makeZmdCChange(zms,trkdata,target);
  526.             break;
  527.         case ZMSCMD_NRPN:                        /* [nrpn] */
  528.             zms = makeZmdSetNRPN(zms, trkdata, target);
  529.             break;
  530.         case ZMSCMD_DAMPER:                        /* [damper] */
  531.             zms = makeZmdDamper(zms, trkdata, target, 1);
  532.             break;
  533.         case ZMSCMD_TRACK_FADER:                /* [track_fader] */
  534.             zms = makeCHfader(zms,trkdata,target,trkinf,cominf,1);
  535.             break;
  536.         case ZMSCMD_CH_FADER:                    /* [ch_fader] */
  537.             zms = makeCHfader(zms,trkdata,target,trkinf,cominf,0);
  538.             break;
  539.  
  540.         case ZMSCMD_EFFECT:                        /* [effect] */
  541.             zms = makeZmdEffect(zms,trkdata,target);
  542.             zms = skipSpc(zms);
  543.             break;
  544.         case ZMSCMD_EFFECT_REVERB:                /* [effect.reverb] */
  545.         case ZMSCMD_EFFECT_CHORUS:                /* [effect.chorus] */
  546.         case ZMSCMD_EFFECT_DELAY:                /* [effect.delay] */
  547.             {
  548.                 BYTE mode;
  549.                 if (i == ZMSCMD_EFFECT_REVERB) {
  550.                     mode = 0;
  551.                 } else if (i == ZMSCMD_EFFECT_CHORUS) {
  552.                     mode = 1;
  553.                 } else if (i == ZMSCMD_EFFECT_DELAY) {
  554.                     mode = 2;
  555.                 }
  556.                 zms = makeZmdEffect2(zms,trkdata,target,mode);
  557.             }
  558.             break;
  559.         case ZMSCMD_MIDI_DATA:                    /* [midi_data] */
  560.             zms = makeZmdExclusive(zms, trkdata, target, 0);
  561.             break;
  562.         case ZMSCMD_ROLAND_EXCLUSIVE:            /* [roland_exclusive] */
  563.             zms = makeZmdExclusive(zms, trkdata, target, 0x41);
  564.             break;
  565.         case ZMSCMD_YAMAHA_EXCLUSIVE:            /* [yamaha_exclusive] */
  566.             zms = makeZmdExclusive(zms, trkdata, target, 0x43);
  567.             break;
  568.         case ZMSCMD_INSTRUMENT_ID:                /* [instrument_id] */
  569.             zms = makeZmdInstrumentId(zms,trkdata,target);
  570.             zms = skipSpc(zms);
  571.             break;
  572.  
  573.         case ZMSCMD_GM_SYSTEM_ON:                /* [gm_system_on] */
  574.             zms = makeZmdGmSystemOn(zms, trkdata, cominf, target);
  575.             break;
  576.         case ZMSCMD_GM2_SYSTEM_ON:                /* [gm2_system_on] */
  577.             zms = makeZmdGm2SystemOn(zms, trkdata, cominf, target);
  578.             break;
  579.         case ZMSCMD_XG_SYSTEM_ON:                /* [xg_system_on] */
  580.             zms = makeZmdXgSystemOn(zms, trkdata, cominf, target);
  581.             break;
  582.  
  583.         case ZMSCMD_SC88_MODE_SET:
  584.         case ZMSCMD_SC88_MODE:
  585.             {
  586.                 int trk;
  587.                 for (trk = 0; target[trk] >= 0; trk++) {
  588.                     const int Trk = target[trk];
  589.                     if (!trkinf[Trk].setdev) {
  590.                         trkinf[Trk].setdev = 1;
  591.                         *trkdata[Trk].zmd++ = 0xCA;
  592.                         *trkdata[Trk].zmd++ = 0x41;
  593.                         *trkdata[Trk].zmd++ = 0x10;
  594.                         *trkdata[Trk].zmd++ = 0x42;
  595.                     }
  596.                 }
  597.                 zms = makeZmdSc88ModeSet(zms, trkdata, target);
  598.             }
  599.             break;
  600.         case ZMSCMD_GATETIME_RESOLUTION:        /* [gatetime_resolution] */
  601.             zms = makeZmdGatetimeResolution(zms,cominf,trkinf,target);
  602.             break;
  603.  
  604.         default:                                /* [] ... pull portament */
  605.             zms = makePortament(zms,trkdata,target,trkinf,cominf,']');
  606.             for (trk = 0; target[trk] >= 0; trk++) {
  607.                 trkinf[target[trk]].noteon = 1;
  608.             }
  609.             break;
  610.     }
  611.     if (*zms == ']') {
  612.         zms++;
  613.     }
  614.  
  615.     return zms;
  616. }
  617.  
  618.  
  619.  
  620. UBYTE *makeCHfader(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  621.                     TRKINF *trkinf, COMMONINF *cominf,
  622.                     int trk_fader)
  623. /* trk_fader: 0=ch_fader 1=trk_fader */
  624. {
  625.     DWORD ch, chtype;
  626.     DWORD zmd, zmd2, diff;
  627.     int trk;
  628.     const BYTE parabytes[3] = {2,1,1};
  629.  
  630.     zmd = trkdata[target[0]].zmd - trkdata[target[0]].zmdbuf;
  631.  
  632.     if (!trk_fader) {
  633.         zms = getDevice(zms, &ch, &chtype,cominf, 1);
  634.         if (*zms == ',') {
  635.             zms++;
  636.         }
  637.     }
  638.     zms = makeZmdManyParas2(zms, trkdata, target, line, linebuf,
  639.                         0xD6, 3, parabytes, 1,    -1,    4,     1,     0,
  640.                     /*  com,  maxparas,   ,omit?,ARCCno, space, times, mustover0 */
  641.                         "[CH_FADER]: too many parameters.",
  642.                         "[CH_FADER] can't use relational parameters.",
  643.                         NULL);
  644.  
  645.     /* zmd2 = trkdata[target[0]].zmd - trkdata[target[0]].zmdbuf; */
  646.     /* diff = zmd2 - zmd; */
  647.     diff = zmd;
  648.  
  649.     for (trk = 0; target[trk] >= 0; trk++) {
  650.         const int Trk = target[trk];
  651.         UBYTE *obp = trkdata[Trk].zmdbuf + diff + 1;
  652.  
  653.         if (!trk_fader) {
  654.             if (chtype == -2) {
  655.                 chtype = -1;
  656.             }
  657.             putWord(obp, chtype);
  658.  
  659.             if (ch == -2) {
  660.                 ch = -1;
  661.             }
  662.             putWord(obp + 2, ch);
  663.         } else {
  664.             putWord(obp,     0x7ffe);
  665.             putWord(obp + 2, 0);        /* current track */
  666.         }
  667.     }
  668.  
  669.     zms = skipSpc(zms);
  670.     if (*zms == ']') {
  671.         zms++;
  672.     }
  673.     return zms;
  674. }
  675.  
  676.  
  677. UBYTE *makeZmdEffect(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[])
  678. {
  679.     const BYTE parabytes[5] = {1,1,1,1,1};
  680.  
  681.     return makeZmdManyParas2(zms,trkdata,target,line,linebuf,
  682.                             0xF0, 5, parabytes, 1, -1, 0, 1, 0,
  683.                             "@e: too many parameters.",
  684.                             "@e can't use relational parameters.",
  685.                             "");
  686. }
  687.  
  688. /* MT-32 is not supported yet */
  689. UBYTE *makeZmdEffect2(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  690.                         const BYTE mode)
  691. {
  692.     int trk, i;
  693.     UBYTE flg = 1;
  694.     DWORD para;
  695.  
  696.     for (i = 0; i < mode; i++) {
  697.         flg <<= 1;
  698.     }
  699.  
  700.     zms = get1AbsPara(zms,¶,0,255,
  701.             "[EFFECT] parameter is out of range(0-255).",
  702.             "[EFFECT] must be followed to its parameter.");
  703.  
  704.     for (trk = 0; target[trk] >= 0; trk++) {
  705.         const int Trk = target[trk];
  706.  
  707.         *trkdata[Trk].zmd++ = 0xF0;
  708.         *trkdata[Trk].zmd++ = flg;
  709.         *trkdata[Trk].zmd++ = para;
  710.     }
  711.  
  712.     return zms;
  713. }
  714.  
  715.  
  716. UBYTE *makeZmdInstrumentId(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[])
  717. {
  718.     return makeZmdManyParas(zms,trkdata,target,line,linebuf,
  719.                             0xCA, 0xFF, 3, 1, 0,
  720.                             "@i must have 3 parameters(maker id,device id,model id).",
  721.                             "@i can't omit 3 parameters(maker id,device id,model id).",
  722.                             "@i can't use relational parameters.");
  723. }
  724.  
  725.  
  726. UBYTE *makeZmdSynchronize(UBYTE *zms_,TRKCHINF *trkdata, const BYTE target[],
  727.                             COMMONINF *cominf)
  728. {
  729.     UBYTE *zms;
  730.     int trk, err;
  731.     DWORD tmpDWORD;
  732.  
  733.     zms = getnum2(zms_, &tmpDWORD, &err);
  734.     for (trk = 0; target[trk] >= 0; trk++) {
  735.         const int Trk = target[trk];
  736.         if (err < 0) {                                /* W  */
  737.             *trkdata[Trk].zmd++ = 0xFB;
  738.         } else {
  739.             int i, f = 0;
  740.             for (i = 0; i < cominf->maxtrk; i++) {    /* Wn */
  741.                 if (cominf->trkassign[i] == tmpDWORD) {
  742.                     *trkdata[Trk].zmd++ = 0xBE;
  743.                     putWord(trkdata[Trk].zmd, i);    /* - 1; */
  744.                     trkdata[Trk].zmd +=2;
  745.                     f = 1;
  746.                     break;
  747.                 }
  748.             }
  749.             if (!f) {
  750.                 zmserror("illegal track number.",line,linebuf,zms,0,1);
  751.             }
  752.         }
  753.     }
  754.     return zms;
  755. }
  756.  
  757.  
  758. UBYTE *makeZmdBar(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  759. {
  760.     while (1) {
  761.         if (*zms == 0x0D || *zms == 0x0A) {
  762.             zmserror("illegal track number.",line,linebuf,zms,0,1);
  763.         } else if (*zms == ']') {
  764.             int trk;
  765.             for (trk = 0; target[trk] >= 0; trk++) {
  766.                 const int Trk = target[trk];
  767.                 *trkdata[Trk].zmd++ = 0xFE;
  768.             }
  769.             break;
  770.         }
  771.     }
  772.  
  773.     return zms;
  774. }
  775.  
  776.  
  777. UBYTE *makeZmdTieMode(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  778. {
  779.     DWORD para;
  780.     int err, trk;
  781.     const char *p[] = {"normal","special","enhanced",NULL};
  782.  
  783.     zms = getnum4(zms,¶,&err, p, -3);
  784.     if (err < 0) {
  785.         para = 0;
  786.     } else if (para == -3) {
  787.         para = 0;
  788.     } else if (para == -2 || para == -1) {
  789.         para = 1;
  790.     }
  791.  
  792.     for (trk = 0; target[trk] >= 0; trk++) {
  793.         const int Trk = target[trk];
  794.         *trkdata[Trk].zmd++ = 0x9E;
  795.         *trkdata[Trk].zmd++ = para;
  796.     }
  797.  
  798.     return zms;
  799. }
  800.  
  801.  
  802. UBYTE *makeZmdTrackMode(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf,
  803.                         const BYTE target[])
  804. {
  805.     DWORD para;
  806.     int err, trk;
  807.     const char *p[] = {"normal","rhythm",NULL};
  808.  
  809.     zms = getnum4(zms,¶,&err, p, -2);
  810.     if (err < 0 || para == -2) {
  811.         para = 0;
  812.     } else {
  813.         para = 0x80;
  814.     }
  815.  
  816.     for (trk = 0; target[trk] >= 0; trk++) {
  817.         const int Trk = target[trk];
  818.         *trkdata[Trk].zmd++ = 0xA4;
  819.         *trkdata[Trk].zmd++ = para;
  820.         if (trkinf[Trk].noteon) {
  821.             trkdata[Trk].trkm = (para)? 1 : 0;
  822.         }
  823.     }
  824.  
  825.     return zms;
  826. }
  827.  
  828.  
  829. UBYTE *makeZmdTrackDelay(UBYTE *zms_, TRKCHINF *trkdata, const BYTE target[],
  830.                     TRKINF *trkinf, COMMONINF *cominf, int mode)
  831. {
  832.     int trk;
  833.     UBYTE *zms;
  834.     DWORD line_ = line;
  835.     LINEDATA *ld_ = ld;
  836.  
  837.     for (trk = 0; target[trk] >= 0; trk++) {
  838.         const int Trk = target[trk];
  839.         UWORD step;
  840.         int err;
  841.  
  842.         line = line_;
  843.         ld = ld_;
  844.         if (!mode) {
  845.             zms = getStep(zms_, &step, trkinf[Trk].Step, &err,cominf);
  846.         } else {
  847.             DWORD s;
  848.  
  849.             zms = getnum2(zms_, &s, &err);
  850.             step = s;
  851.         }
  852.  
  853.         *trkdata[Trk].zmd++ = 0x81;
  854.         trkdata[Trk].zmd += putZvar(trkdata[Trk].zmd, step);
  855.  
  856.         zms = skipSpcCr(zms);
  857.         if (*zms == '&') {            /* @w with TIE */
  858.             zmserror("@w can't use with TIE on V3.",line,linebuf,zms,0,1);
  859.         }
  860.         incrementStepCounters(&trkinf[Trk], step);
  861.     }
  862.  
  863.     return zms;
  864. }
  865.  
  866.  
  867. void makeZmdAllSoundOff(TRKCHINF *trkdata, const BYTE target[])
  868. {
  869.     int trk;
  870.  
  871.     for (trk = 0; target[trk] >= 0; trk++) {
  872.         *trkdata[target[trk]].zmd++ = 0xFD;
  873.     }
  874. }
  875.  
  876.  
  877. UBYTE *makeZmdEcho(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf,
  878.                         const BYTE target[], COMMONINF *cominf)
  879. {
  880.     DWORD    para;
  881.     int        err, trk;
  882.     UWORD    itv;
  883.     UBYTE    *zms_ = zms;
  884.     const char *p[] = {"loop",NULL};
  885.  
  886.     for (trk = 0; target[trk] >= 0; trk++) {
  887.         const int Trk = target[trk];
  888.         zms = getStep(zms_, &itv, trkinf[Trk].Step,&err,cominf);
  889.  
  890.         if (itv <= 0) {
  891.             zmserror("ECHO's 1st parameter must be over 0.",line,linebuf,zms,0,1);
  892.         }
  893.         trkinf[Trk].echoitv = itv;
  894.         if (*zms == ',') {
  895.             zms++;
  896.         }
  897.         zms = skipSpc(zms);
  898.         if (*zms == ']') {
  899.             break;
  900.         }
  901.  
  902.         zms = getnum2(zms, ¶,&err);
  903.         if (err > 0) {
  904.             zmserror("ECHO's 2nd parameter error.",line,linebuf,zms,0,1);
  905.         }
  906.         trkinf[Trk].echodec = para;
  907.         if (*zms == ',') {
  908.             zms++;
  909.         }
  910.         zms = skipSpc(zms);
  911.         if (*zms == ']') {
  912.             break;
  913.         }
  914.  
  915.         zms = getnum4(zms,¶,&err, p, 0);
  916.         if (err > 0 || para < 0) {
  917.             zmserror("ECHO's 3rd parameter error.",line,linebuf,zms,0,1);
  918.         }
  919.         trkinf[Trk].echolp = para;
  920.     }
  921.  
  922.     return zms;
  923. }
  924.  
  925.  
  926. UBYTE *makeZmdDamper(UBYTE *zms, TRKCHINF *trkdata,
  927.                          const BYTE target[], int mode)
  928. {
  929.     DWORD para;
  930.     int err, trk;
  931.     const char *p[] = {"off","on",NULL};
  932.  
  933.     zms = getnum4(zms,¶,&err, p, -2);
  934.     if (err < 0 || para == -2) {
  935.         para = 0;
  936.     } else if (para == -1) {
  937.         para = 127;
  938.     }
  939.  
  940.     for (trk = 0; target[trk] >= 0; trk++) {
  941.         const int Trk = target[trk];
  942.         *trkdata[Trk].zmd++ = 0xA3;
  943.         if (mode) {
  944.             *trkdata[Trk].zmd++ = para;
  945.         } else {
  946.             *trkdata[Trk].zmd++ = (para)? 127 : 0;
  947.         }
  948.     }
  949.  
  950.     return zms;
  951. }
  952.  
  953.  
  954. UBYTE *makeZmdBendRange(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  955. {
  956.     DWORD para;
  957.     int err, trk;
  958.  
  959.     zms = getnum2(zms,¶,&err);
  960.     if (err < 0) {
  961.         zmserror("@g can't omit its parameter.",line,linebuf,zms,0,1);
  962.     }
  963.  
  964.     for (trk = 0; target[trk] >= 0; trk++) {
  965.         const int Trk = target[trk];
  966.         *trkdata[Trk].zmd++ = 0xA5;
  967.         *trkdata[Trk].zmd++ = para;
  968.     }
  969.  
  970.     return zms;
  971. }
  972.  
  973.  
  974. UBYTE *makeZmdProgramChange(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  975. {
  976.     int trk, err, cmd = 0;
  977.     DWORD tone, b1, b2 = 0;
  978.  
  979.     zms = getnum2(zms,&tone,&err);
  980.     if (!err) {
  981.         zms = skipSpc(zms);
  982.         if (*zms == ':' && *(zms + 1) != '|') {        /* @n1:n2,n3 */
  983.             cmd = 1;
  984.             b1 = tone;
  985.             zms = getnum2(zms + 1, &b2, &err);
  986.             if (err) {
  987.                 b2  = 0xFF;
  988.             }
  989.             zms = skipSpc(zms);
  990.             if (*zms == ',') {
  991.                 zms = getnum2(zms + 1, &tone, &err);
  992.                 if (err) {
  993.                     zmserror("`@'(program set) error.",line,linebuf,zms,0,1);
  994.                 }
  995.             } else {
  996.                 zmserror("`@'(program set) error.",line,linebuf,zms,0,1);
  997.             }
  998.         } else if (*zms == ',') {    /* @n1,n2 */
  999.             cmd = 2;
  1000.             b1 = (tone >> 7) & 0x7F;
  1001.             b2 = tone & 0x7F;
  1002.             zms = getnum2(zms + 1, &tone, &err);
  1003.             if (err) {
  1004.                 zmserror("`@'(program set) error.",line,linebuf,zms,0,1);
  1005.             }
  1006.         }
  1007.  
  1008.         for (trk = 0; target[trk] >= 0; trk++) {
  1009.             const int Trk = target[trk];
  1010.  
  1011.             if (cmd) {
  1012.                 *trkdata[Trk].zmd++ = 0xC6;
  1013.                 *trkdata[Trk].zmd++ = b1;
  1014.                 *trkdata[Trk].zmd++ = b2;
  1015.             }
  1016.             *trkdata[Trk].zmd++ = 0xC7;
  1017.             putWord(trkdata[Trk].zmd, tone - 1);
  1018.             trkdata[Trk].zmd += 2;
  1019.         }
  1020.     } else {
  1021.         zmserror("`@'(program set) must be followed to its parameter.",line,linebuf,zms,0,1);
  1022.     }
  1023.     return zms;
  1024. }
  1025.  
  1026.  
  1027. UBYTE *makeZmdProgramBankChange(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  1028. {
  1029.     return makeZmdManyParas(zms,trkdata,target,line,linebuf,
  1030.                                 0xC6, 0x00, 2, 1, 1,
  1031.                                 "i: too many parameters.",
  1032.                                 "i: can't use relational parameters.",
  1033.                                 "");
  1034. }
  1035.  
  1036.  
  1037. UBYTE *makeZmdSetNRPN(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  1038. {
  1039.     int trk;
  1040.     const DWORD line_ = line;
  1041.     LINEDATA *ld_ = ld;
  1042.     UBYTE *zms_ = zms;
  1043.  
  1044.     for (trk = 0; target[trk] >= 0; trk++) {
  1045.         const int Trk = target[trk];
  1046.         UWORD bytes = 0;
  1047.  
  1048.         line = line_;
  1049.         ld = ld_;
  1050.         zms = zms_ - 1;
  1051.         *trkdata[Trk].zmd++ = 0xCF;
  1052.         do {
  1053.             int err;
  1054.             DWORD tmpDWORD;
  1055.  
  1056.             zms = getnum2(++zms,&tmpDWORD,&err);
  1057.             if (err >= 0) {
  1058.                 if (tmpDWORD >= 0x80) {
  1059.                     *trkdata[Trk].zmd++ = tmpDWORD & 0x7F;
  1060.                     *trkdata[Trk].zmd++ = tmpDWORD >> 7;
  1061.                     bytes += 2;
  1062.                 } else {
  1063.                     *trkdata[Trk].zmd++ = tmpDWORD;
  1064.                     bytes++;
  1065.                 }
  1066.                 zms = skipSpcCr(zms);
  1067.             } else {
  1068.                 break;
  1069.             }
  1070.         } while(*zms == ',');
  1071.         if (bytes < 3) {
  1072.             zmserror("NRPN must have address(2 bytes) and data(1 or 2 bytes.)",line,linebuf,zms,0,1);
  1073.         } else {
  1074.             int i;
  1075.             for (i = bytes; i < 4; i++) {
  1076.                 *trkdata[Trk].zmd++ = 0xFF;
  1077.             }
  1078.         }
  1079.     }
  1080.  
  1081.     return zms;
  1082. }
  1083.  
  1084.  
  1085. /*tenuki*/
  1086. UBYTE *makeZmdCChange(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[])
  1087. {
  1088.     int trk;
  1089.     DWORD tmpDWORD;
  1090.     UBYTE *zms_ = zms;
  1091.     const DWORD line_ = line;
  1092.     LINEDATA *ld_ = ld;
  1093.  
  1094.     for (trk = 0; target[trk] >= 0; trk++) {
  1095.         int i;
  1096. /* (BEGIN FM/ADPCMsupport by Mamiya */
  1097.         if (checkInternalDevice(trkdata,target[trk])) {
  1098.             int err ;
  1099.             DWORD reg, dat ;
  1100.             line = line_;
  1101.             ld = ld_;
  1102.             zms = getnum2(zms_, ®, &err) ;
  1103.             if (err < 0) {
  1104.                 zmserror("control change must have 2 parameters.",line,linebuf,zms,0,1);
  1105.                 continue;
  1106.             }
  1107.             zms = skipSpcCr(zms);
  1108.             if (*zms != ',') {
  1109.                 zmserror("control change must have 2 parameters.",line,linebuf,zms,0,1);
  1110.                 continue;
  1111.             }
  1112.             zms = getnum2(zms + 1, &dat, &err) ;
  1113.             if (err < 0) {
  1114.                 zmserror("control change must have 2 parameters.",line,linebuf,zms,0,1);
  1115.                 continue;
  1116.             }
  1117.             if (reg < 0x38 && reg == 0x30 + trkdata[target[trk]].ch) {
  1118.                 *trkdata[target[trk]].zmd++ = 0xD1;
  1119.                 dat >>= 2;
  1120.                 putWord(trkdata[target[trk]].zmd, dat);
  1121.                 dat *= 683;
  1122.                 dat >>= 6;
  1123.                 putWord(trkdata[target[trk]].zmd + 2, dat);
  1124.                 trkdata[target[trk]].zmd += 4;
  1125.                 continue;
  1126.             }
  1127.             switch (reg) {
  1128.                 case 2:
  1129.                     dat &= 511 ;
  1130.                     *trkdata[target[trk]].zmd++ = 0x9B;
  1131.                     putWord(trkdata[target[trk]].zmd, dat);
  1132.                     trkdata[target[trk]].zmd += 2 ;
  1133.                     break ;
  1134.                 case 3:
  1135.                     *trkdata[target[trk]].zmd++ = 0xB7;
  1136.                     *trkdata[target[trk]].zmd++ = dat & 3;
  1137.                     break ;
  1138.                 case 13:
  1139.                     *trkdata[target[trk]].zmd++ = 0xA2;
  1140.                     *trkdata[target[trk]].zmd++ = dat & 7;
  1141.                     break ;
  1142.                 case 14:
  1143.                     *trkdata[target[trk]].zmd++ = 0xB8;
  1144.                     *trkdata[target[trk]].zmd++ = dat & 1;
  1145.                     break ;
  1146.                 case 15:
  1147.                     if (dat == 0) {
  1148.                         *trkdata[target[trk]].zmd++ = 0x82;
  1149.                     } else {
  1150.                         *trkdata[target[trk]].zmd++ = 0xA5;
  1151.                         *trkdata[target[trk]].zmd++ = dat;
  1152.                     }
  1153.                     break ;
  1154.                 default:
  1155.                     *trkdata[target[trk]].zmd++ = 0xBC;
  1156.                     *trkdata[target[trk]].zmd++ = reg;
  1157.                     *trkdata[target[trk]].zmd++ = dat;
  1158.                     break ;
  1159.             }
  1160.             continue ;
  1161.         }
  1162. /* FM/ADPCMsupport by Mamiya END) */
  1163.         *trkdata[target[trk]].zmd++ = 0xBC;
  1164.         zms = zms_ - 1;
  1165.  
  1166.         line = line_;
  1167.         ld = ld_;
  1168.         for (i = 0; i < 2; i++) {
  1169.             zms = get1AbsPara(++zms,&tmpDWORD,0,127,
  1170.                     "control change parameter is out of range(0-127).",
  1171.                     "'y'(control change) must be followed to its parameter.");
  1172.             *trkdata[target[trk]].zmd++ = tmpDWORD;
  1173.             zms = skipSpcCr(zms);
  1174.             if (i != 2 - 1 && *zms != ',') {
  1175.                 zmserror("control change must have 2 parameters.",line,linebuf,zms,0,1);
  1176.             }
  1177.         }
  1178.     }
  1179.  
  1180.     return zms;
  1181. }
  1182.  
  1183.  
  1184.  
  1185. UBYTE *makeZmdKsign(UBYTE *zms, const BYTE target[],TRKINF *trkinf)
  1186. {
  1187.     int trk;
  1188.     UBYTE *zms_ = zms;
  1189.     const DWORD line_ = line;
  1190.     LINEDATA *ld_ = ld;
  1191.  
  1192.     for (trk = 0; target[trk] >= 0; trk++) {
  1193.         const int Trk = target[trk];
  1194.         int i,kp = 0,kpflg = 0;
  1195.         int var[2] = { 0, 0 };
  1196.         const BYTE tonetbl[7] = { 0, 2, 4, 5, 7, 9, 11 };
  1197.  
  1198.         zms = skipSpcCr(zms_);
  1199.         line = line_;
  1200.         ld = ld_;
  1201.         for (i = 0; i < 12; i++) {
  1202.             trkinf[Trk].ksign[i] = 0;
  1203.         }
  1204.  
  1205.         if (*zms != '#' && *zms != '+' && *zms != '-') {
  1206.             zms = makeZmdKey0(zms, var);
  1207.             if (var[1] >= 0) {
  1208.                 const char *cho="fcgdaeb";
  1209.  
  1210. /*                fprintf(stderr,"[%d %d] ",var[0], var[1]);*/
  1211.                 if (var[0] > 0) {
  1212.                     int i;
  1213.                     for (i = 0; i < var[0]; i++) {
  1214.                         int note = cho[i] - 'a' - 2;
  1215.  
  1216.                         if (note < 0) {
  1217.                             note += 7;
  1218.                         }
  1219.                         trkinf[Trk].ksign[tonetbl[note]] = 1;
  1220.                     }
  1221.                 } else if (var[0] < 0) {
  1222.                     int i;
  1223.                     for (i = 7; i > 7+var[0]; i--) {
  1224.                         int note = cho[i] - 'a' - 2;
  1225.  
  1226.                         if (note < 0) {
  1227.                             note += 7;
  1228.                         }
  1229.                         trkinf[Trk].ksign[tonetbl[note]] = -1;
  1230.                     }
  1231.                 }
  1232.                 zms = skipSpc(zms);
  1233.             }
  1234.         }
  1235.  
  1236.         while (*zms != ']') {
  1237.             int note;
  1238.  
  1239.             zms = skipSpcCr(zms);
  1240.             switch(*zms++) {
  1241.                 case '#':
  1242.                 case '+':
  1243.                     if (kpflg) {
  1244.                         kp = 1;
  1245.                         kpflg = 0;
  1246.                     } else {
  1247.                         kp++;
  1248.                     }
  1249.                     break;
  1250.                 case '-':
  1251.                     if (kpflg) {
  1252.                         kp = -1;
  1253.                         kpflg = 0;
  1254.                     } else {
  1255.                         kp--;
  1256.                     }
  1257.                     break;
  1258.                 case 'a':    case 'A':    case 'b':    case 'B':
  1259.                 case 'c':    case 'C':    case 'd':    case 'D':
  1260.                 case 'e':    case 'E':    case 'f':    case 'F':
  1261.                 case 'g':    case 'G':
  1262.                     kpflg = 1;
  1263.                     note = (*(zms  - 1) | 0x20) - 'a';
  1264.                     note -= 2;
  1265.                     if (note < 0) {
  1266.                         note += 7;
  1267.                     }
  1268.                     trkinf[Trk].ksign[tonetbl[note]] = kp;
  1269.                     break;
  1270.                 case ',':
  1271.                     break;
  1272.                 default:
  1273.                     zmserror("ksign error.",line,linebuf,zms,0,1);
  1274.                     break;
  1275.             }
  1276.             zms = skipSpcCr(zms);
  1277.         }
  1278.     }
  1279.  
  1280.     return zms;
  1281. }
  1282.  
  1283.  
  1284. /*tenuki*/
  1285. UBYTE *makeZmdReplay(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[])
  1286. {
  1287.     int trk, err;
  1288.     DWORD para;
  1289.  
  1290.     zms = getnum2(zms, ¶, &err);
  1291.  
  1292.     if (!err) {
  1293.         for (trk = 0; target[trk] >= 0; trk++) {
  1294.             const int Trk = target[trk];
  1295.  
  1296.             *trkdata[Trk].zmd++ = 0xbd;
  1297.             putWord(trkdata[Trk].zmd, para);
  1298.             trkdata[Trk].zmd += 2;
  1299.         }
  1300.     } else {
  1301.         zmserror("J/[REPLAY] requires the target track parameter.",line,linebuf,zms,0,1);
  1302.     }
  1303.     return zms;
  1304. }
  1305.  
  1306.  
  1307. void makeZmdDummy(TRKCHINF *trkdata, const BYTE target[])
  1308. {
  1309.     int trk;
  1310.  
  1311.     for (trk = 0; target[trk] >= 0; trk++) {
  1312.         const int Trk = target[trk];
  1313.  
  1314.         *trkdata[Trk].zmd++ = 0xfa;
  1315.     }
  1316. }
  1317.  
  1318.  
  1319. UBYTE *makeZmdComment(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  1320. {
  1321.     int trk;
  1322.     UBYTE *zms_;
  1323.     DWORD len;
  1324.  
  1325.     zms_ = zms = skipSpc(zms);
  1326.     while (*zms != ']' && *zms != 0x0d && *zms != 0x0a) {
  1327.         zms++;
  1328.     }
  1329.     if (*zms == 0x0d || *zms == 0x0a) {
  1330.         zmserror("[comment] format error.",line,linebuf,zms,0,1);
  1331.     }
  1332.  
  1333.     len = zms - zms_;
  1334.     for (trk = 0; target[trk] >= 0; trk++) {
  1335.         const int Trk = target[trk];
  1336.         int i;
  1337.  
  1338.         *trkdata[Trk].zmd++ = 0xd2;
  1339.         *trkdata[Trk].zmd++ = 0;
  1340.         putDword(trkdata[Trk].zmd, len);
  1341.         trkdata[Trk].zmd += 4;
  1342.         for (i = 0; i < len; i++) {
  1343.             *trkdata[Trk].zmd++ = *zms_++;
  1344.         }
  1345.     }
  1346.  
  1347.     return zms;
  1348. }
  1349.  
  1350.  
  1351. UBYTE *makeZmdEvent(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[])
  1352. {
  1353.     const char *category[] = {"word", "picture","sound",NULL};
  1354.     const char *cls0[] = {"string",NULL};
  1355.     const char *cls1[] = {"pic",NULL};
  1356.     const char *cls2[] = {"adpcm",NULL};
  1357.     char **class_[3];        /* = {cls0,cls1,cls2} */    /* BCB can't do so */
  1358.     int trk,err;
  1359.     UBYTE *zms_, *obp;
  1360.     DWORD len,cat,cls;
  1361.  
  1362.     class_[0] = (char**)cls0;
  1363.     class_[1] = (char**)cls1;
  1364.     class_[2] = (char**)cls2;
  1365.  
  1366.     zms = getnum4(zms,&cat,&err, category, 0);
  1367.  
  1368.     if (err) {
  1369.         zmserror("SYNTAX ERROR",line,linebuf,zms,0,1);
  1370.     } else if (cat < 0 && 2 < cat) {
  1371.         zmserror("EVENT category is not defined.",line,linebuf,zms,0,1);
  1372.     }
  1373.     if (cat > 0) {
  1374.         zmserror("EVENT PICTURE/SOUND is not supported in z2m3.",line,linebuf,zms,4,1);
  1375.     }
  1376.     zms = skipSpc(zms);
  1377.     if (*zms == ',') {
  1378.         zms++;
  1379.     }
  1380.  
  1381.     zms = getnum4(zms,&cls,&err, (const char**)class_[cat], 0);
  1382.     if (err) {
  1383.         zmserror("SYNTAX ERROR",line,linebuf,zms,0,1);
  1384.     } else if (cls < 0 && 2 < cls) {
  1385.         zmserror("EVENT class is not defined.",line,linebuf,zms,0,1);
  1386.     }
  1387.     zms = skipSpc(zms);
  1388.     if (*zms == ',') {
  1389.         zms++;
  1390.     }
  1391.  
  1392.     zms = skipSpc(zms);
  1393.     if (*zms == '\"') {
  1394.         zms++;
  1395.     }
  1396.  
  1397.     zms_ = zms;
  1398.     while (*zms != ']' && *zms != '\"' && *zms != 0x0d && *zms != 0x0a) {
  1399.         zms++;
  1400.     }
  1401.     if (*zms == 0x0d || *zms == 0x0a) {
  1402.         zmserror("[event] format error.",line,linebuf,zms,0,1);
  1403.     }
  1404.  
  1405.     len = zms - zms_;
  1406.     for (trk = 0; target[trk] >= 0; trk++) {
  1407.         const int Trk = target[trk];
  1408.         int i;
  1409.  
  1410.         *trkdata[Trk].zmd++ = 0xf8;
  1411.         putDword(trkdata[Trk].zmd, 1 + 1 + 2 + len + 1);
  1412.         trkdata[Trk].zmd += 4;
  1413.         *trkdata[Trk].zmd++ = cat;
  1414.         *trkdata[Trk].zmd++ = cls;
  1415.         *trkdata[Trk].zmd++ = 0;
  1416.         *trkdata[Trk].zmd++ = 0;
  1417.  
  1418.         for (i = 0; i < len; i++) {
  1419.             *trkdata[Trk].zmd++ = *zms_++;
  1420.         }
  1421.         *trkdata[Trk].zmd++ = '\0';
  1422.     }
  1423.  
  1424.     if (*zms == '\"') {
  1425.         zms++;
  1426.     }
  1427.     if (*zms == ']') {
  1428.         zms++;
  1429.     }
  1430.     return zms;
  1431. }
  1432.  
  1433.  
  1434.  
  1435. UBYTE *makeZmdPanpot(UBYTE *zms, TRKCHINF *trkdata, const BYTE target[], int mode)
  1436. {    /* mode=-1: P  mode=0: @P  mode=1: [@PANPOT] */
  1437.     int trk;
  1438.     const DWORD line_ = line;
  1439.     LINEDATA *ld_ = ld;
  1440.     UBYTE *zms_ = zms;
  1441.     UBYTE *linebuf_ = linebuf;
  1442.  
  1443.     for (trk = 0; target[trk] >= 0; trk++) {
  1444.         const int Trk = target[trk];
  1445.         const int tbl[] = {128, 0, 127, 64};
  1446.         BYTE rel = 0;
  1447.         DWORD vol;    /* ,v = trkinf[Trk].vol; */
  1448.         int err;
  1449.  
  1450.         line = line_;
  1451.         ld = ld_;
  1452.         zms = skipSpcCr(zms_);
  1453.         if (*zms == '+') {
  1454.             rel = 1;
  1455.         } else if (*zms == '-') {
  1456.             rel = -1;
  1457.         }
  1458.         zms = getnum2(zms, &vol, &err);
  1459.         if (mode < 0) {
  1460.             if (rel) {
  1461.                 zmserror("P (panpot) must be followed to its absolute parameter.",line_,linebuf_,zms_,0,1);
  1462.             } else {
  1463.                 vol = tbl[vol];        /* tenuki */
  1464.             }
  1465.         }
  1466.  
  1467.         if (err < 0) {                /* only '@p' */
  1468.             zmserror("@p must be followed to its parameter.",line_,linebuf_,zms_,0,1);
  1469.         } else {
  1470.             if (rel || mode > 0) {
  1471.                 *trkdata[Trk].zmd++ = 0xA1;
  1472.                 *trkdata[Trk].zmd++ = vol;
  1473.             } else {
  1474.                 if (vol < 0 || vol > 127) {
  1475.                     zmserror("panpot parameter is out of range(0-127).",line_,linebuf_,zms_,0,1);
  1476.                 } else {
  1477.                     *trkdata[Trk].zmd++ = 0xA0;
  1478.                     *trkdata[Trk].zmd++ = vol;
  1479.                 }
  1480.             }
  1481.             /* trkinf[Trk].vol = v; */
  1482.         }
  1483.     }
  1484.  
  1485.     return zms;
  1486. }
  1487.  
  1488.  
  1489. UBYTE *makeZmdTempo(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[], int mode)
  1490. {    /* [TEMPO] mode=0: absolute  mode=1: relative */
  1491.     /* [TIMER] mode=2: absolute  mode=3: relative */
  1492.     UBYTE *zms_ = zms;
  1493.     int trk;
  1494.     char *linebuf_ = linebuf;
  1495.     DWORD line_ = line;
  1496.     LINEDATA *ld_ = ld;
  1497.  
  1498.     for (trk = 0; target[trk] >= 0; trk++) {
  1499.         const int Trk = target[trk];
  1500.         int err, rel = 0;
  1501.         DWORD vol;
  1502.  
  1503.         line = line_;
  1504.         ld = ld_;
  1505.         zms = skipSpcCr(zms_);
  1506.         if (*zms == '+') {
  1507.             rel = 1;
  1508.         } else if (*zms == '-') {
  1509.             rel = -1;
  1510.         }
  1511.         zms = getnum2(zms, &vol, &err);
  1512.  
  1513.         if (err < 0) {                /* only '@v' */
  1514.             zmserror("tempo must be followed to its parameter.",line_,linebuf_,zms_,0,1);
  1515.         } else {
  1516.             if (rel || (mode & 1)) {
  1517.                 *trkdata[Trk].zmd++ = (mode & 2)? 0xC2 : 0xC4;
  1518.                 putWord(trkdata[Trk].zmd, vol);
  1519.                 trkdata[Trk].zmd += 2;
  1520.             } else {
  1521.                 if (!(mode & 2) && (vol < 20 || 300 < vol)) {
  1522.                     zmserror("tempo parameter is out of range(20 - 300).",line_,linebuf_,zms_,0,1);
  1523.                 } else {
  1524.                     *trkdata[Trk].zmd++ = (mode & 2)? 0xC1 : 0xC3;
  1525.                     putWord(trkdata[Trk].zmd, vol);
  1526.                     trkdata[Trk].zmd += 2;
  1527.                 }
  1528.             }
  1529.         }
  1530.     }
  1531.  
  1532.     return zms;
  1533. }
  1534.  
  1535.  
  1536. UBYTE *makeZmdVolume(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  1537.                         TRKINF *trkinf, int mode)
  1538. {    /* mode=0:V  mode=1:@V  mode=-1:[@VOLUME] */
  1539.     UBYTE *zms_ = zms;
  1540.     DWORD line_ = line;
  1541.     UBYTE *linebuf_ = linebuf;
  1542.     LINEDATA *ld_ = ld;
  1543.  
  1544.     int trk;
  1545.     for (trk = 0; target[trk] >= 0; trk++) {
  1546.         const int Trk = target[trk];
  1547.         BYTE rel = 0;
  1548.         DWORD vol;    /* ,v = trkinf[target[trk]].vol; */
  1549.         int err;
  1550.  
  1551.         line = line_;
  1552.         ld = ld_;
  1553.         zms = skipSpcCr(zms_);
  1554.         if (*zms == '+') {
  1555.             rel = 1;
  1556.         } else if (*zms == '-') {
  1557.             rel = -1;
  1558.         }
  1559.         zms = getnum2(zms, &vol, &err);
  1560.  
  1561.         if (err < 0) {                /* only '@v' */
  1562.             zmserror("v/@v must be followed to its parameter.",line_,linebuf_,zms_,0,1);
  1563.         } else {
  1564.             if (rel || mode > 0) {
  1565. /* WARNING: v+ || v- will be fail */
  1566.                 *trkdata[Trk].zmd++ = 0x91;
  1567.                 *trkdata[Trk].zmd++ = vol;
  1568. /* (BEGIN FM/ADPCMsupport by Mamiya */
  1569.                 if (checkInternalDevice(trkdata,Trk) & 1) {
  1570.                     DWORD v = trkinf[Trk].velou.var[0];
  1571.                     v += vol ;
  1572.                     v = (v < 0) ? 0 : ((v > 127) ? 127 : v) ;
  1573.                     trkinf[Trk].velou.var[0] = v ;
  1574.                 }
  1575. /* FM/ADPCMsupport by Mamiya END) */
  1576.                 /* zmserror("@v is used relatively.",line_,linebuf_,zms_,4,1); */
  1577.             } else {
  1578.                 if ( (!mode && (vol < 0 || vol > 127)) ||
  1579.                     ( (mode < 0) && (vol < 0 || vol > 16)) ) {
  1580.                     zmserror("v/@v parameter is out of range.",line_,linebuf_,zms_,0,1);
  1581.                 } else {
  1582.                     *trkdata[Trk].zmd++ = 0x90;
  1583.                     *trkdata[Trk].zmd++ = (mode < 0)? 0x80 + vol : vol;
  1584. /* (BEGIN FM/ADPCMsupport by Mamiya */
  1585.                     if (checkInternalDevice(trkdata,Trk) & 1) {
  1586.                         trkinf[Trk].velou.var[0] = vol ;
  1587.                     }
  1588. /* FM/ADPCMsupport by Mamiya END) */
  1589.                 }
  1590.             }
  1591.             trkinf[Trk].volmode = (mode < 0)? 1 : 0;
  1592.             /* trkinf[Trk].vol = v; */
  1593.         }
  1594.     }
  1595.  
  1596.     return zms;
  1597. }
  1598.  
  1599.  
  1600.  
  1601. UBYTE *makeZmdExclusive(UBYTE *zms,TRKCHINF *trkdata,
  1602.                             const BYTE target[], const UBYTE id)
  1603. {
  1604.     int trk;
  1605.     DWORD line_ = line;
  1606.     UBYTE *zms_ = zms;
  1607.     LINEDATA *ld_ = ld;
  1608.  
  1609.     for (trk = 0; target[trk] >= 0; trk++) {
  1610.         UBYTE *zmd_;
  1611.         const int Trk = target[trk];
  1612.  
  1613.         line = line_;
  1614.         ld = ld_;
  1615.         zms = zms_ - 1;
  1616.  
  1617.         if (id) {
  1618.             *trkdata[Trk].zmd++ = 0xF3;
  1619.             *trkdata[Trk].zmd++ = id;
  1620.         } else {
  1621.             *trkdata[Trk].zmd++ = 0xF4;
  1622.         }
  1623.         *trkdata[Trk].zmd++ = 0x00;        /* comment length */
  1624.         zmd_ = trkdata[Trk].zmd;
  1625.         trkdata[Trk].zmd += 4;
  1626.  
  1627.         do {
  1628.             DWORD zmsbyte = 0;
  1629.  
  1630.             trkdata[Trk].zmd = txt2bin(trkdata[Trk].zmd, ++zms, &zmsbyte);
  1631.             zms += zmsbyte;
  1632.             if (!zmsbyte) {
  1633.                 break;
  1634.             }
  1635.         } while(*zms == ',' || isspace(*zms));
  1636.  
  1637.         putDword(zmd_, trkdata[Trk].zmd - zmd_ - 4);
  1638.     }
  1639.  
  1640.     return zms;
  1641. }
  1642.  
  1643.  
  1644. void makeZmdPitch(TRKCHINF *trkdata, int Trk, int st, DWORD var)
  1645. {
  1646.     UBYTE code;
  1647.  
  1648.     switch (st) {
  1649.         case 0:
  1650.             code = 0xB9;
  1651.             break;
  1652.         case 1:
  1653.             code = 0xB8;
  1654.             break;
  1655.         case 2:
  1656.             code = 0xBB;
  1657.             break;
  1658.         case 3:
  1659.             code = 0xBA;
  1660.             break;
  1661.     }
  1662.     *trkdata[Trk].zmd++ = code;
  1663.     putWord(trkdata[Trk].zmd, var);
  1664.     trkdata[Trk].zmd += 2;
  1665. }
  1666.  
  1667.  
  1668. UBYTE *makeZmdBend(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf, const BYTE target[], int st)
  1669. {
  1670.     int trk;
  1671.     DWORD line_ = line;
  1672.     LINEDATA *ld_ = ld;
  1673.     UBYTE *linebuf_ = linebuf;
  1674.     UBYTE *zms_ = zms;
  1675.  
  1676.     for (trk = 0; target[trk] >= 0; trk++) {
  1677. /*
  1678.         const UBYTE mml = *(zms_ - 1);
  1679.         const int st = (mml == 'b' || mml == 'B')? 1 : 0;
  1680. */
  1681.         const int Trk = target[trk];
  1682.         DWORD tmpDWORD;
  1683.         int err;
  1684.  
  1685.         line = line_;
  1686.         ld = ld_;
  1687.         zms = getnum2(zms_, &tmpDWORD, &err);
  1688.         zms = skipSpc(zms);
  1689.         if (err < 0 && *zms !=',') {                /* autobend sw off */
  1690. /*OK*/        *trkdata[Trk].zmd++ = 0x98;
  1691.             *trkdata[Trk].zmd++ = 0x00;
  1692.         } else {
  1693. /*OK*/        if (*zms == ',') {                        /* @bnnn,NNN */
  1694.                 DWORD tmpDWORD2, delay;
  1695.                 int errs[4] = {-2,-2,-2,-2};
  1696.                 DWORD p[4] = {0,0,0,0};
  1697.                 int i;
  1698.                 UBYTE of = (err != -1)? 1 : 0;
  1699.  
  1700.                 errs[0] = err;
  1701.                 p[0] = tmpDWORD;
  1702.                 for (i = 1; i < 4; i++) {
  1703.                     of <<= 1;
  1704.                     zms = getnum2(++zms, &p[i], &errs[i]);
  1705.                     zms = skipSpc(zms);
  1706.                     if (errs[i] > 0) {
  1707.                         zmserror("@b/@k can't omit delay parameter when you want to set.",line_,linebuf_,zms_,0,1);
  1708.                     } else if (errs[i] != -1) {
  1709.                         of++;
  1710.                         if (i == 2) {
  1711.                             trkinf[Trk].abdelay = p[2];
  1712.                         }
  1713.                     }
  1714.                     if (*zms != ',') {
  1715.                         int j;
  1716.                         for (j = i + 1; j < 8; j++) {
  1717.                             of <<= 1;
  1718.                         }
  1719.                         break;
  1720.                     }
  1721.                 }
  1722.  
  1723.                 *trkdata[Trk].zmd++ = (st)? 0xE0 : 0xE1;
  1724.                 *trkdata[Trk].zmd++ = of;
  1725.                 for (i = 0; i < 4; i++) {
  1726.                     if (errs[i] >= 0) {
  1727.                         putWord(trkdata[Trk].zmd, p[i]);
  1728.                         trkdata[Trk].zmd += 2;
  1729.                     }
  1730.                 }
  1731.             } else {                                /* @bnnn */
  1732. /*OK*/            makeZmdPitch(trkdata, Trk, st, tmpDWORD);
  1733.             }
  1734.         }
  1735.     }
  1736.  
  1737.     return zms;
  1738. }
  1739.  
  1740.  
  1741. UBYTE *makeZmdProgramSplit(UBYTE *zms, TRKCHINF *trkdata, TRKINF *trkinf, const BYTE target[])
  1742. {
  1743.     int trk;
  1744.     DWORD line_ = line;
  1745.     UBYTE *linebuf_ = linebuf;
  1746.     UBYTE *zms_ = zms;
  1747.     LINEDATA *ld_ = ld;
  1748.  
  1749.  
  1750.     for (trk = 0; target[trk] >= 0; trk++) {
  1751.         const int Trk = target[trk];
  1752.         const int octbak = trkinf[Trk].octave;
  1753.         const char *p[] = {"off","on",NULL};
  1754.         DWORD sw = 1;
  1755.         int paras = 0, err;
  1756.         UBYTE *zmd_;
  1757.  
  1758.         linebuf = linebuf_;
  1759.         line = line_;
  1760.         ld = ld_;
  1761.  
  1762.         *trkdata[Trk].zmd++ = 0xDE;
  1763.         zmd_ = trkdata[Trk].zmd;
  1764.         trkdata[Trk].zmd++;
  1765.  
  1766.         zms = getnum4(zms_,&sw,&err, p, 0);
  1767.         if (err || sw) {
  1768.             sw = 0x80;
  1769.         }
  1770.         zms = skipSpcCr(zms);
  1771.         if (*zms == ',') {
  1772.             zms++;
  1773.         }
  1774.         if (*zms != ']') {
  1775.  
  1776.             while (1) {
  1777.                 int err;
  1778.                 DWORD b1, b2 = 0, t1;
  1779.                 BYTE m1, n1;
  1780.  
  1781.                 linebuf = linebuf_;
  1782.                 line = line;
  1783.                 ld = ld_;
  1784.  
  1785.                 zms = getnum2(zms, &b1, &err);
  1786.                 if (err) {
  1787.                     zmserror("[timbre_split] parameter error.",line,linebuf,zms,0,1);
  1788.                 }
  1789.                 zms = skipSpcCr(zms);
  1790.                 if (*zms == ':') {
  1791.                     zms = getnum2(zms + 1, &b2, &err);
  1792.                     if (err) {
  1793.                         zmserror("[timbre_split] parameter error.",line,linebuf,zms,0,1);
  1794.                     }
  1795.                     b1 <<= 7;
  1796.                     b1 += b2;
  1797.                 }
  1798.                 if (*zms == ',') {
  1799.                     zms++;
  1800.                 }
  1801.                 zms = getnum2(zms, &t1, &err);
  1802.                 if (*zms == ',') {
  1803.                     zms++;
  1804.                 }
  1805.                 zms = getZmsNoteSub(zms, trkinf ,Trk, &m1);
  1806.                 if (*zms == ',') {
  1807.                     zms++;
  1808.                 }
  1809.                 zms = getZmsNoteSub(zms, trkinf, Trk, &n1);
  1810.  
  1811.                 *trkdata[Trk].zmd++ = m1;
  1812.                 *trkdata[Trk].zmd++ = n1;
  1813.                 putWord(trkdata[Trk].zmd, b1);
  1814.                 trkdata[Trk].zmd += 2;
  1815.                 putWord(trkdata[Trk].zmd, t1 - 1);
  1816.                 trkdata[Trk].zmd += 2;
  1817.  
  1818.                 paras++;
  1819.                 zms = skipSpcCr(zms);
  1820.                 if (*zms != ',') {
  1821.                     break;
  1822.                 } else {
  1823.                     zms++;
  1824.                 }
  1825.             }
  1826.         }
  1827.         *zmd_ = sw + paras;
  1828.         trkinf[Trk].octave = octbak;
  1829.     }
  1830.     return zms;
  1831. }
  1832.  
  1833.  
  1834. UBYTE *getZmsNoteSub(UBYTE *zms, TRKINF *trkinf, const int Trk, BYTE *note)
  1835. {
  1836.     *note = (trkinf[Trk].octave  + 1) * 12;
  1837.  
  1838.     while (1) {
  1839.         if (*zms == 'o' || *zms == 'O') {
  1840.             zms = checkOctaveChange(zms, trkinf, Trk);
  1841.             *note = (trkinf[Trk].octave  + 1) * 12;
  1842.         } else if (*zms == '<') {
  1843.             *note += 12;
  1844.             trkinf[Trk].octave++;
  1845.             zms++;
  1846.         } else if (*zms == '>') {
  1847.             *note -= 12;
  1848.             trkinf[Trk].octave--;
  1849.             zms++;
  1850.         } else if ('a' <= tolower(*zms) && tolower(*zms) <= 'g') {
  1851.             const BYTE tonetbl[7] = { 0, 2, 4, 5, 7, 9, 11 };
  1852.             BYTE n = tolower(*zms) - 'a' - 2;
  1853.  
  1854.             if (n < 0) {
  1855.                 n += 7;
  1856.             }
  1857.             *note += tonetbl[n];
  1858.             zms++;
  1859.         } else if (*zms == '#' || *zms == '+') {
  1860.             note++;
  1861.             zms++;
  1862.         } else if (*zms == '-') {
  1863.             note--;
  1864.             zms++;
  1865.         } else if (isspace(*zms)) {
  1866.             zms++;
  1867.         } else if (isdigit(*zms)) {
  1868.             DWORD tmp;
  1869.             int err;
  1870.  
  1871.             zms = getnum2(zms, &tmp, &err);
  1872.             *note = tmp;
  1873.         } else {
  1874.             break;
  1875.         }
  1876.     }
  1877.  
  1878.     return zms;
  1879. }
  1880.